3/**
 * we-cropper v1.3.9
 * (c) 2020 dlhandsome
 * @license MIT
 */

const { default: defaults } = require("../../utils/request/lib/core/defaults");

var WeCropper;

(function (global, factory) {
  typeof exports === "object" && typeof module !== "undefined"
    ? (module.exports = factory())
    : typeof define === "function" && define.amd
    ? define(factory)
    : (global.WeCropper = factory());
})(this, function () {
  "use strict";

  var device = void 0;
  var TOUCH_STATE = ["touchstarted", "touchmoved", "touchended"];

  function firstLetterUpper(str) {
    return str.charAt(0).toUpperCase() + str.slice(1);
  }

  function setTouchState(instance) {
    var arg = [],
      len = arguments.length - 1;
    while (len-- > 0) arg[len] = arguments[len + 1];

    TOUCH_STATE.forEach(function (key, i) {
      if (arg[i] !== undefined) {
        instance[key] = arg[i];
      }
    });
  }

  function validator(instance, o) {
    Object.defineProperties(instance, o);
  }

  function getDevice() {
    if (!device) {
      device = uni.getSystemInfoSync();
    }
    return device;
  }

  var tmp = {};

  var ref = getDevice();
  var pixelRatio = ref.pixelRatio;

  var DEFAULT = {
    id: {
      default: "cropper",
      get: function get() {
        return tmp.id;
      },
      set: function set(value) {
        if (typeof value !== "string") {
          console.error("id：" + value + " is invalid");
        }
        tmp.id = value;
      },
    },
    width: {
      default: 750,
      get: function get() {
        return tmp.width;
      },
      set: function set(value) {
        if (typeof value !== "number") {
          console.error("width：" + value + " is invalid");
        }
        tmp.width = value;
      },
    },
    height: {
      default: 750,
      get: function get() {
        return tmp.height;
      },
      set: function set(value) {
        if (typeof value !== "number") {
          console.error("height：" + value + " is invalid");
        }
        tmp.height = value;
      },
    },
    pixelRatio: {
      default: pixelRatio,
      get: function get() {
        return tmp.pixelRatio;
      },
      set: function set(value) {
        if (typeof value !== "number") {
          console.error("pixelRatio：" + value + " is invalid");
        }
        tmp.pixelRatio = value;
      },
    },
    scale: {
      default: 2.5,
      get: function get() {
        return tmp.scale;
      },
      set: function set(value) {
        if (typeof value !== "number") {
          console.error("scale：" + value + " is invalid");
        }
        tmp.scale = value;
      },
    },
    zoom: {
      default: 5,
      get: function get() {
        return tmp.zoom;
      },
      set: function set(value) {
        if (typeof value !== "number") {
          console.error("zoom：" + value + " is invalid");
        } else if (value < 0 || value > 10) {
          console.error("zoom should be ranged in 0 ~ 10");
        }
        tmp.zoom = value;
      },
    },
    src: {
      default: "",
      get: function get() {
        return tmp.src;
      },
      set: function set(value) {
        if (typeof value !== "string") {
          console.error("src：" + value + " is invalid");
        }
        tmp.src = value;
      },
    },
    cut: {
      default: {},
      get: function get() {
        return tmp.cut;
      },
      set: function set(value) {
        if (typeof value !== "object") {
          console.error("cut：" + value + " is invalid");
        }
        tmp.cut = value;
      },
    },
    boundStyle: {
      default: {},
      get: function get() {
        return tmp.boundStyle;
      },
      set: function set(value) {
        if (typeof value !== "object") {
          console.error("boundStyle：" + value + " is invalid");
        }
        tmp.boundStyle = value;
      },
    },
    onReady: {
      default: null,
      get: function get() {
        return tmp.ready;
      },
      set: function set(value) {
        tmp.ready = value;
      },
    },
    onBeforeImageLoad: {
      default: null,
      get: function get() {
        return tmp.beforeImageLoad;
      },
      set: function set(value) {
        tmp.beforeImageLoad = value;
      },
    },
    onImageLoad: {
      default: null,
      get: function get() {
        return tmp.imageLoad;
      },
      set: function set(value) {
        tmp.imageLoad = value;
      },
    },
    onBeforeDraw: {
      default: null,
      get: function get() {
        return tmp.beforeDraw;
      },
      set: function set(value) {
        tmp.beforeDraw = value;
      },
    },
  };

  var ref$1 = getDevice();
  var windowWidth = ref$1.windowWidth;

  function prepare() {
    var self = this;

    // v1.4.0 版本中将不再自动绑定we-cropper实例
    self.attachPage = function () {
      var pages = getCurrentPages();
      // 获取到当前page上下文
      var pageContext = pages[pages.length - 1];
      // 把this依附在Page上下文的wecropper属性上，便于在page钩子函数中访问
      Object.defineProperty(pageContext, "wecropper", {
        get: function get() {
          console.warn(
            "Instance will not be automatically bound to the page after v1.4.0\n\n" +
              "Please use a custom instance name instead\n\n" +
              "Example: \n" +
              "this.mycropper = new WeCropper(options)\n\n" +
              "// ...\n" +
              "this.mycropper.getCropperImage()"
          );
          return self;
        },
        configurable: true,
      });
    };

    self.createCtx = function () {
      var id = self.id;
      var targetId = self.targetId;

      if (id) {
        self.ctx = self.ctx || uni.createCanvasContext(id);
        self.targetCtx = self.targetCtx || uni.createCanvasContext(targetId);
      } else {
        console.error(
          "constructor: create canvas context failed, 'id' must be valuable"
        );
      }
    };

    self.deviceRadio = windowWidth / 750;
  }

  var commonjsGlobal =
    typeof window !== "undefined"
      ? window
      : typeof global !== "undefined"
      ? global
      : typeof self !== "undefined"
      ? self
      : {};

  function createCommonjsModule(fn, module) {
    return (
      (module = {
        exports: {},
      }),
      fn(module, module.exports),
      module.exports
    );
  }

  var tools = createCommonjsModule(function (module, exports) {
    /**
     * String type check
     */
    exports.isStr = function (v) {
      return typeof v === "string";
    };
    /**
     * Number type check
     */
    exports.isNum = function (v) {
      return typeof v === "number";
    };
    /**
     * Array type check
     */
    exports.isArr = Array.isArray;
    /**
     * undefined type check
     */
    exports.isUndef = function (v) {
      return v === undefined;
    };

    exports.isTrue = function (v) {
      return v === true;
    };

    exports.isFalse = function (v) {
      return v === false;
    };
    /**
     * Function type check
     */
    exports.isFunc = function (v) {
      return typeof v === "function";
    };
    /**
     * Quick object check - this is primarily used to tell
     * Objects from primitive values when we know the value
     * is a JSON-compliant type.
     */
    exports.isObj = exports.isObject = function (obj) {
      return obj !== null && typeof obj === "object";
    };

    /**
     * Strict object type check. Only returns true
     * for plain JavaScript objects.
     */
    var _toString = Object.prototype.toString;
    exports.isPlainObject = function (obj) {
      return _toString.call(obj) === "[object Object]";
    };

    /**
     * Check whether the object has the property.
     */
    var hasOwnProperty = Object.prototype.hasOwnProperty;
    exports.hasOwn = function (obj, key) {
      return hasOwnProperty.call(obj, key);
    };

    /**
     * Perform no operation.
     * Stubbing args to make Flow happy without leaving useless transpiled code
     * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/)
     */
    exports.noop = function (a, b, c) {};

    /**
     * Check if val is a valid array index.
     */
    exports.isValidArrayIndex = function (val) {
      var n = parseFloat(String(val));
      return n >= 0 && Math.floor(n) === n && isFinite(val);
    };
  });

  var tools_7 = tools.isFunc;
  var tools_10 = tools.isPlainObject;

  var EVENT_TYPE = ["ready", "beforeImageLoad", "beforeDraw", "imageLoad"];

  function observer() {
    var self = this;

    self.on = function (event, fn) {
      if (EVENT_TYPE.indexOf(event) > -1) {
        if (tools_7(fn)) {
          event === "ready"
            ? fn(self)
            : (self["on" + firstLetterUpper(event)] = fn);
        }
      } else {
        console.error("event: " + event + " is invalid");
      }
      return self;
    };
  }

  function wxPromise(fn) {
    return function (obj) {
      var args = [],
        len = arguments.length - 1;
      while (len-- > 0) args[len] = arguments[len + 1];

      if (obj === void 0) obj = {};
      return new Promise(function (resolve, reject) {
        obj.success = function (res) {
          resolve(res);
        };
        obj.fail = function (err) {
          reject(err);
        };
        fn.apply(void 0, [obj].concat(args));
      });
    };
  }

  function draw(ctx, reserve) {
    if (reserve === void 0) reserve = false;

    return new Promise(function (resolve) {
      ctx.draw(reserve, resolve);
    });
  }

  var getImageInfo = wxPromise(uni.getImageInfo);

  var canvasToTempFilePath = wxPromise(uni.canvasToTempFilePath);

  var base64 = createCommonjsModule(function (module, exports) {
    /*! http://mths.be/base64 v0.1.0 by @mathias | MIT license */
    (function (root) {
      // Detect free variables `exports`.
      var freeExports = "object" == "object" && exports;

      // Detect free variable `module`.
      var freeModule =
        "object" == "object" &&
        module &&
        module.exports == freeExports &&
        module;

      // Detect free variable `global`, from Node.js or Browserified code, and use
      // it as `root`.
      var freeGlobal = typeof commonjsGlobal == "object" && commonjsGlobal;
      if (
        freeGlobal.global === freeGlobal ||
        freeGlobal.window === freeGlobal
      ) {
        root = freeGlobal;
      }

      /*--------------------------------------------------------------------------*/

      var InvalidCharacterError = function (message) {
        this.message = message;
      };
      InvalidCharacterError.prototype = new Error();
      InvalidCharacterError.prototype.name = "InvalidCharacterError";

      var error = function (message) {
        // Note: the error messages used throughout this file match those used by
        // the native `atob`/`btoa` implementation in Chromium.
        throw new InvalidCharacterError(message);
      };

      var TABLE =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
      // http://whatwg.org/html/common-microsyntaxes.html#space-character
      var REGEX_SPACE_CHARACTERS = /[\t\n\f\r ]/g;

      // `decode` is designed to be fully compatible with `atob` as described in the
      // HTML Standard. http://whatwg.org/html/webappapis.html#dom-windowbase64-atob
      // The optimized base64-decoding algorithm used is based on @atk’s excellent
      // implementation. https://gist.github.com/atk/1020396
      var decode = function (input) {
        input = String(input).replace(REGEX_SPACE_CHARACTERS, "");
        var length = input.length;
        if (length % 4 == 0) {
          input = input.replace(/==?$/, "");
          length = input.length;
        }
        if (
          length % 4 == 1 ||
          // http://whatwg.org/C#alphanumeric-ascii-characters
          /[^+a-zA-Z0-9/]/.test(input)
        ) {
          error(
            "Invalid character: the string to be decoded is not correctly encoded."
          );
        }
        var bitCounter = 0;
        var bitStorage;
        var buffer;
        var output = "";
        var position = -1;
        while (++position < length) {
          buffer = TABLE.indexOf(input.charAt(position));
          bitStorage = bitCounter % 4 ? bitStorage * 64 + buffer : buffer;
          // Unless this is the first of a group of 4 characters…
          if (bitCounter++ % 4) {
            // …convert the first 8 bits to a single ASCII character.
            output += String.fromCharCode(
              0xff & (bitStorage >> ((-2 * bitCounter) & 6))
            );
          }
        }
        return output;
      };

      // `encode` is designed to be fully compatible with `btoa` as described in the
      // HTML Standard: http://whatwg.org/html/webappapis.html#dom-windowbase64-btoa
      var encode = function (input) {
        input = String(input);
        if (/[^\0-\xFF]/.test(input)) {
          // Note: no need to special-case astral symbols here, as surrogates are
          // matched, and the input is supposed to only contain ASCII anyway.
          error(
            "The string to be encoded contains characters outside of the " +
              "Latin1 range."
          );
        }
        var padding = input.length % 3;
        var output = "";
        var position = -1;
        var a;
        var b;
        var c;
        var buffer;
        // Make sure any padding is handled outside of the loop.
        var length = input.length - padding;

        while (++position < length) {
          // Read three bytes, i.e. 24 bits.
          a = input.charCodeAt(position) << 16;
          b = input.charCodeAt(++position) << 8;
          c = input.charCodeAt(++position);
          buffer = a + b + c;
          // Turn the 24 bits into four chunks of 6 bits each, and append the
          // matching character for each of them to the output.
          output +=
            TABLE.charAt((buffer >> 18) & 0x3f) +
            TABLE.charAt((buffer >> 12) & 0x3f) +
            TABLE.charAt((buffer >> 6) & 0x3f) +
            TABLE.charAt(buffer & 0x3f);
        }

        if (padding == 2) {
          a = input.charCodeAt(position) << 8;
          b = input.charCodeAt(++position);
          buffer = a + b;
          output +=
            TABLE.charAt(buffer >> 10) +
            TABLE.charAt((buffer >> 4) & 0x3f) +
            TABLE.charAt((buffer << 2) & 0x3f) +
            "=";
        } else if (padding == 1) {
          buffer = input.charCodeAt(position);
          output +=
            TABLE.charAt(buffer >> 2) +
            TABLE.charAt((buffer << 4) & 0x3f) +
            "==";
        }

        return output;
      };

      var base64 = {
        encode: encode,
        decode: decode,
        version: "0.1.0",
      };

      // Some AMD build optimizers, like r.js, check for specific condition patterns
      // like the following:
      if (
        typeof undefined == "function" &&
        typeof undefined.amd == "object" &&
        undefined.amd
      ) {
        undefined(function () {
          return base64;
        });
      } else if (freeExports && !freeExports.nodeType) {
        if (freeModule) {
          // in Node.js or RingoJS v0.8.0+
          freeModule.exports = base64;
        } else {
          // in Narwhal or RingoJS v0.7.0-
          for (var key in base64) {
            base64.hasOwnProperty(key) && (freeExports[key] = base64[key]);
          }
        }
      } else {
        // in Rhino or a web browser
        root.base64 = base64;
      }
    })(commonjsGlobal);
  });

  function makeURI(strData, type) {
    return "data:" + type + ";base64," + strData;
  }

  function fixType(type) {
    type = type.toLowerCase().replace(/jpg/i, "jpeg");
    var r = type.match(/png|jpeg|bmp|gif/)[0];
    return "image/" + r;
  }

  function encodeData(data) {
    var str = "";
    if (typeof data === "string") {
      str = data;
    } else {
      for (var i = 0; i < data.length; i++) {
        str += String.fromCharCode(data[i]);
      }
    }
    return base64.encode(str);
  }

  /**
   * 获取图像区域隐含的像素数据
   * @param canvasId canvas标识
   * @param x 将要被提取的图像数据矩形区域的左上角 x 坐标
   * @param y 将要被提取的图像数据矩形区域的左上角 y 坐标
   * @param width 将要被提取的图像数据矩形区域的宽度
   * @param height 将要被提取的图像数据矩形区域的高度
   * @param done 完成回调
   */
  function getImageData(canvasId, x, y, width, height, done) {
    uni.canvasGetImageData({
      canvasId: canvasId,
      x: x,
      y: y,
      width: width,
      height: height,
      success: function success(res) {
        done(res, null);
      },
      fail: function fail(res) {
        done(null, res);
      },
    });
  }

  /**
   * 生成bmp格式图片
   * 按照规则生成图片响应头和响应体
   * @param oData 用来描述 canvas 区域隐含的像素数据 { data, width, height } = oData
   * @returns {*} base64字符串
   */
  function genBitmapImage(oData) {
    //
    // BITMAPFILEHEADER: http://msdn.microsoft.com/en-us/library/windows/desktop/dd183374(v=vs.85).aspx
    // BITMAPINFOHEADER: http://msdn.microsoft.com/en-us/library/dd183376.aspx
    //
    var biWidth = oData.width;
    var biHeight = oData.height;
    var biSizeImage = biWidth * biHeight * 3;
    var bfSize = biSizeImage + 54; // total header size = 54 bytes

    //
    //  typedef struct tagBITMAPFILEHEADER {
    //  	WORD bfType;
    //  	DWORD bfSize;
    //  	WORD bfReserved1;
    //  	WORD bfReserved2;
    //  	DWORD bfOffBits;
    //  } BITMAPFILEHEADER;
    //
    var BITMAPFILEHEADER = [
      // WORD bfType -- The file type signature; must be "BM"
      0x42,
      0x4d,
      // DWORD bfSize -- The size, in bytes, of the bitmap file
      bfSize & 0xff,
      (bfSize >> 8) & 0xff,
      (bfSize >> 16) & 0xff,
      (bfSize >> 24) & 0xff,
      // WORD bfReserved1 -- Reserved; must be zero
      0,
      0,
      // WORD bfReserved2 -- Reserved; must be zero
      0,
      0,
      // DWORD bfOffBits -- The offset, in bytes, from the beginning of the BITMAPFILEHEADER structure to the bitmap bits.
      54,
      0,
      0,
      0,
    ];

    //
    //  typedef struct tagBITMAPINFOHEADER {
    //  	DWORD biSize;
    //  	LONG  biWidth;
    //  	LONG  biHeight;
    //  	WORD  biPlanes;
    //  	WORD  biBitCount;
    //  	DWORD biCompression;
    //  	DWORD biSizeImage;
    //  	LONG  biXPelsPerMeter;
    //  	LONG  biYPelsPerMeter;
    //  	DWORD biClrUsed;
    //  	DWORD biClrImportant;
    //  } BITMAPINFOHEADER, *PBITMAPINFOHEADER;
    //
    var BITMAPINFOHEADER = [
      // DWORD biSize -- The number of bytes required by the structure
      40,
      0,
      0,
      0,
      // LONG biWidth -- The width of the bitmap, in pixels
      biWidth & 0xff,
      (biWidth >> 8) & 0xff,
      (biWidth >> 16) & 0xff,
      (biWidth >> 24) & 0xff,
      // LONG biHeight -- The height of the bitmap, in pixels
      biHeight & 0xff,
      (biHeight >> 8) & 0xff,
      (biHeight >> 16) & 0xff,
      (biHeight >> 24) & 0xff,
      // WORD biPlanes -- The number of planes for the target device. This value must be set to 1
      1,
      0,
      // WORD biBitCount -- The number of bits-per-pixel, 24 bits-per-pixel -- the bitmap
      // has a maximum of 2^24 colors (16777216, Truecolor)
      24,
      0,
      // DWORD biCompression -- The type of compression, BI_RGB (code 0) -- uncompressed
      0,
      0,
      0,
      0,
      // DWORD biSizeImage -- The size, in bytes, of the image. This may be set to zero for BI_RGB bitmaps
      biSizeImage & 0xff,
      (biSizeImage >> 8) & 0xff,
      (biSizeImage >> 16) & 0xff,
      (biSizeImage >> 24) & 0xff,
      // LONG biXPelsPerMeter, unused
      0,
      0,
      0,
      0,
      // LONG biYPelsPerMeter, unused
      0,
      0,
      0,
      0,
      // DWORD biClrUsed, the number of color indexes of palette, unused
      0,
      0,
      0,
      0,
      // DWORD biClrImportant, unused
      0,
      0,
      0,
      0,
    ];

    var iPadding = (4 - ((biWidth * 3) % 4)) % 4;

    var aImgData = oData.data;

    var strPixelData = "";
    var biWidth4 = biWidth << 2;
    var y = biHeight;
    var fromCharCode = String.fromCharCode;

    do {
      var iOffsetY = biWidth4 * (y - 1);
      var strPixelRow = "";
      for (var x = 0; x < biWidth; x++) {
        var iOffsetX = x << 2;
        strPixelRow +=
          fromCharCode(aImgData[iOffsetY + iOffsetX + 2]) +
          fromCharCode(aImgData[iOffsetY + iOffsetX + 1]) +
          fromCharCode(aImgData[iOffsetY + iOffsetX]);
      }

      for (var c = 0; c < iPadding; c++) {
        strPixelRow += String.fromCharCode(0);
      }

      strPixelData += strPixelRow;
    } while (--y);

    var strEncoded =
      encodeData(BITMAPFILEHEADER.concat(BITMAPINFOHEADER)) +
      encodeData(strPixelData);

    return strEncoded;
  }

  /**
   * 转换为图片base64
   * @param canvasId canvas标识
   * @param x 将要被提取的图像数据矩形区域的左上角 x 坐标
   * @param y 将要被提取的图像数据矩形区域的左上角 y 坐标
   * @param width 将要被提取的图像数据矩形区域的宽度
   * @param height 将要被提取的图像数据矩形区域的高度
   * @param type 转换图片类型
   * @param done 完成回调
   */
  function convertToImage(canvasId, x, y, width, height, type, done) {
    if (done === void 0) done = function () {};

    if (type === undefined) {
      type = "png";
    }
    type = fixType(type);
    if (/bmp/.test(type)) {
      getImageData(canvasId, x, y, width, height, function (data, err) {
        var strData = genBitmapImage(data);
        tools_7(done) && done(makeURI(strData, "image/" + type), err);
      });
    } else {
      console.error("暂不支持生成'" + type + "'类型的base64图片");
    }
  }

  var CanvasToBase64 = {
    convertToImage: convertToImage,
    // convertToPNG: function (width, height, done) {
    //   return convertToImage(width, height, 'png', done)
    // },
    // convertToJPEG: function (width, height, done) {
    //   return convertToImage(width, height, 'jpeg', done)
    // },
    // convertToGIF: function (width, height, done) {
    //   return convertToImage(width, height, 'gif', done)
    // },
    convertToBMP: function (ref, done) {
      if (ref === void 0) ref = {};
      var canvasId = ref.canvasId;
      var x = ref.x;
      var y = ref.y;
      var width = ref.width;
      var height = ref.height;
      if (done === void 0) done = function () {};

      return convertToImage(canvasId, x, y, width, height, "bmp", done);
    },
  };

  function methods() {
    var self = this;

    var boundWidth = self.width; // 裁剪框默认宽度，即整个画布宽度
    var boundHeight = self.height; // 裁剪框默认高度，即整个画布高度

    var id = self.id;
    var targetId = self.targetId;
    var pixelRatio = self.pixelRatio;

    var ref = self.cut;
    var x = ref.x;
    if (x === void 0) x = 0;
    var y = ref.y;
    if (y === void 0) y = 0;
    var width = ref.width;
    if (width === void 0) width = boundWidth;
    var height = ref.height;
    if (height === void 0) height = boundHeight;

    self.updateCanvas = function (done) {
      if (self.croperTarget) {
        //  画布绘制图片
        self.ctx.drawImage(
          self.croperTarget,
          self.imgLeft,
          self.imgTop,
          self.scaleWidth,
          self.scaleHeight
        );
      }
      tools_7(self.onBeforeDraw) && self.onBeforeDraw(self.ctx, self);

      self.setBoundStyle(self.boundStyle); //	设置边界样式

      self.ctx.draw(false, done);
      return self;
    };

    self.pushOrigin = self.pushOrign = function (src) {
      self.src = src;

      tools_7(self.onBeforeImageLoad) && self.onBeforeImageLoad(self.ctx, self);

      return getImageInfo({
        src: src,
      })
        .then(function (res) {
          var innerAspectRadio = res.width / res.height;
          var customAspectRadio = width / height;

          self.croperTarget = res.path;

          if (innerAspectRadio < customAspectRadio) {
            self.rectX = x;
            self.baseWidth = width;
            self.baseHeight = width / innerAspectRadio;
            self.rectY = y - Math.abs((height - self.baseHeight) / 2);
          } else {
            self.rectY = y;
            self.baseWidth = height * innerAspectRadio;
            self.baseHeight = height;
            self.rectX = x - Math.abs((width - self.baseWidth) / 2);
          }

          self.imgLeft = self.rectX;
          self.imgTop = self.rectY;
          self.scaleWidth = self.baseWidth;
          self.scaleHeight = self.baseHeight;

          self.update();

          return new Promise(function (resolve) {
            self.updateCanvas(resolve);
          });
        })
        .then(function () {
          tools_7(self.onImageLoad) && self.onImageLoad(self.ctx, self);
        });
    };

    self.removeImage = function () {
      self.src = "";
      self.croperTarget = "";
      return draw(self.ctx);
    };

    self.getCropperBase64 = function (done) {
      if (done === void 0) done = function () {};

      CanvasToBase64.convertToBMP(
        {
          canvasId: id,
          x: x,
          y: y,
          width: width,
          height: height,
        },
        done
      );
    };

    self.getCropperImage = function (opt, fn) {
      var customOptions = opt;

      var canvasOptions = {
        canvasId: id,
        x: x,
        y: y,
        width: width,
        height: height,
      };

      var task = function () {
        return Promise.resolve();
      };

      if (tools_10(customOptions) && customOptions.original) {
        // original mode
        task = function () {
          self.targetCtx.drawImage(
            self.croperTarget,
            self.imgLeft * pixelRatio,
            self.imgTop * pixelRatio,
            self.scaleWidth * pixelRatio,
            self.scaleHeight * pixelRatio
          );

          canvasOptions = {
            canvasId: targetId,
            x: x * pixelRatio,
            y: y * pixelRatio,
            width: width * pixelRatio,
            height: height * pixelRatio,
          };

          return draw(self.targetCtx);
        };
      }

      return task()
        .then(function () {
          if (tools_10(customOptions)) {
            canvasOptions = Object.assign({}, canvasOptions, customOptions);
          }

          if (tools_7(customOptions)) {
            fn = customOptions;
          }

          var arg = canvasOptions.componentContext
            ? [canvasOptions, canvasOptions.componentContext]
            : [canvasOptions];

          return canvasToTempFilePath.apply(null, arg);
        })
        .then(function (res) {
          var tempFilePath = res.tempFilePath;

          return tools_7(fn) ? fn.call(self, tempFilePath, null) : tempFilePath;
        })
        .catch(function (err) {
          if (tools_7(fn)) {
            fn.call(self, null, err);
          } else {
            throw err;
          }
        });
    };
  }

  /**
   * 获取最新缩放值
   * @param oldScale 上一次触摸结束后的缩放值
   * @param oldDistance 上一次触摸结束后的双指距离
   * @param zoom 缩放系数
   * @param touch0 第一指touch对象
   * @param touch1 第二指touch对象
   * @returns {*}
   */
  var getNewScale = function (oldScale, oldDistance, zoom, touch0, touch1) {
    var xMove, yMove, newDistance;
    // 计算二指最新距离
    xMove = Math.round(touch1.x - touch0.x);
    yMove = Math.round(touch1.y - touch0.y);
    newDistance = Math.round(Math.sqrt(xMove * xMove + yMove * yMove));

    return oldScale + 0.001 * zoom * (newDistance - oldDistance);
  };

  function update() {
    var self = this;

    if (!self.src) {
      return;
    }

    self.__oneTouchStart = function (touch) {
      self.touchX0 = Math.round(touch.x);
      self.touchY0 = Math.round(touch.y);
    };

    self.__oneTouchMove = function (touch) {
      var xMove, yMove;
      // 计算单指移动的距离
      if (self.touchended) {
        return self.updateCanvas();
      }
      xMove = Math.round(touch.x - self.touchX0);
      yMove = Math.round(touch.y - self.touchY0);

      var imgLeft = Math.round(self.rectX + xMove);
      var imgTop = Math.round(self.rectY + yMove);

      self.outsideBound(imgLeft, imgTop);

      self.updateCanvas();
    };

    self.__twoTouchStart = function (touch0, touch1) {
      var xMove, yMove, oldDistance;

      self.touchX1 = Math.round(self.rectX + self.scaleWidth / 2);
      self.touchY1 = Math.round(self.rectY + self.scaleHeight / 2);

      // 计算两指距离
      xMove = Math.round(touch1.x - touch0.x);
      yMove = Math.round(touch1.y - touch0.y);
      oldDistance = Math.round(Math.sqrt(xMove * xMove + yMove * yMove));

      self.oldDistance = oldDistance;
    };

    self.__twoTouchMove = function (touch0, touch1) {
      var oldScale = self.oldScale;
      var oldDistance = self.oldDistance;
      var scale = self.scale;
      var zoom = self.zoom;

      self.newScale = getNewScale(oldScale, oldDistance, zoom, touch0, touch1);

      //  设定缩放范围
      self.newScale <= 1 && (self.newScale = 1);
      self.newScale >= scale && (self.newScale = scale);

      self.scaleWidth = Math.round(self.newScale * self.baseWidth);
      self.scaleHeight = Math.round(self.newScale * self.baseHeight);
      var imgLeft = Math.round(self.touchX1 - self.scaleWidth / 2);
      var imgTop = Math.round(self.touchY1 - self.scaleHeight / 2);

      self.outsideBound(imgLeft, imgTop);

      self.updateCanvas();
    };

    self.__xtouchEnd = function () {
      self.oldScale = self.newScale;
      self.rectX = self.imgLeft;
      self.rectY = self.imgTop;
    };
  }

  var handle = {
    //  图片手势初始监测
    touchStart: function touchStart(e) {
      var self = this;
      var ref = e.touches;
      var touch0 = ref[0];
      var touch1 = ref[1];

      if (!self.src) {
        return;
      }

      setTouchState(self, true, null, null);

      // 计算第一个触摸点的位置，并参照改点进行缩放
      self.__oneTouchStart(touch0);

      // 两指手势触发
      if (e.touches.length >= 2) {
        self.__twoTouchStart(touch0, touch1);
      }
    },

    //  图片手势动态缩放
    touchMove: function touchMove(e) {
      var self = this;
      var ref = e.touches;
      var touch0 = ref[0];
      var touch1 = ref[1];

      if (!self.src) {
        return;
      }

      setTouchState(self, null, true);

      // 单指手势时触发
      if (e.touches.length === 1) {
        self.__oneTouchMove(touch0);
      }
      // 两指手势触发
      if (e.touches.length >= 2) {
        self.__twoTouchMove(touch0, touch1);
      }
    },

    touchEnd: function touchEnd(e) {
      var self = this;

      if (!self.src) {
        return;
      }

      setTouchState(self, false, false, true);
      self.__xtouchEnd();
    },
  };

  function cut() {
    var self = this;
    var boundWidth = self.width; // 裁剪框默认宽度，即整个画布宽度
    var boundHeight = self.height;
    // 裁剪框默认高度，即整个画布高度
    var ref = self.cut;
    var x = ref.x;
    if (x === void 0) x = 0;
    var y = ref.y;
    if (y === void 0) y = 0;
    var width = ref.width;
    if (width === void 0) width = boundWidth;
    var height = ref.height;
    if (height === void 0) height = boundHeight;

    /**
     * 设置边界
     * @param imgLeft 图片左上角横坐标值
     * @param imgTop 图片左上角纵坐标值
     */
    self.outsideBound = function (imgLeft, imgTop) {
      self.imgLeft =
        imgLeft >= x
          ? x
          : self.scaleWidth + imgLeft - x <= width
          ? x + width - self.scaleWidth
          : imgLeft;

      self.imgTop =
        imgTop >= y
          ? y
          : self.scaleHeight + imgTop - y <= height
          ? y + height - self.scaleHeight
          : imgTop;
    };

    /**
     * 设置边界样式
     * @param color	边界颜色
     */
    self.setBoundStyle = function (ref) {
      if (ref === void 0) ref = {};
      var color = ref.color;
      if (color === void 0) color = "#04b00f";
      var mask = ref.mask;
      if (mask === void 0) mask = "rgba(0, 0, 0, 0.3)";
      var lineWidth = ref.lineWidth;
      if (lineWidth === void 0) lineWidth = 1;

      var half = lineWidth / 2;
      var boundOption = [
        {
          start: {
            x: x - half,
            y: y + 10 - half,
          },
          step1: {
            x: x - half,
            y: y - half,
          },
          step2: {
            x: x + 10 - half,
            y: y - half,
          },
        },
        {
          start: {
            x: x - half,
            y: y + height - 10 + half,
          },
          step1: {
            x: x - half,
            y: y + height + half,
          },
          step2: {
            x: x + 10 - half,
            y: y + height + half,
          },
        },
        {
          start: {
            x: x + width - 10 + half,
            y: y - half,
          },
          step1: {
            x: x + width + half,
            y: y - half,
          },
          step2: {
            x: x + width + half,
            y: y + 10 - half,
          },
        },
        {
          start: {
            x: x + width + half,
            y: y + height - 10 + half,
          },
          step1: {
            x: x + width + half,
            y: y + height + half,
          },
          step2: {
            x: x + width - 10 + half,
            y: y + height + half,
          },
        },
      ];

      // 绘制半透明层
      self.ctx.beginPath();
      self.ctx.setFillStyle(mask);
      self.ctx.fillRect(0, 0, x, boundHeight);
      self.ctx.fillRect(x, 0, width, y);
      self.ctx.fillRect(x, y + height, width, boundHeight - y - height);
      self.ctx.fillRect(x + width, 0, boundWidth - x - width, boundHeight);
      self.ctx.fill();

      boundOption.forEach(function (op) {
        self.ctx.beginPath();
        self.ctx.setStrokeStyle(color);
        self.ctx.setLineWidth(lineWidth);
        self.ctx.moveTo(op.start.x, op.start.y);
        self.ctx.lineTo(op.step1.x, op.step1.y);
        self.ctx.lineTo(op.step2.x, op.step2.y);
        self.ctx.stroke();
      });
    };
  }

  var version = "1.3.9";

  WeCropper = function WeCropper(params) {
    var self = this;
    var _default = {};

    validator(self, DEFAULT);

    Object.keys(DEFAULT).forEach(function (key) {
      _default[key] = DEFAULT[key].default;
    });
    Object.assign(self, _default, params);

    self.prepare();
    self.attachPage();
    self.createCtx();
    self.observer();
    self.cutt();
    self.methods();
    self.init();
    self.update();

    return self;
  };

  WeCropper.prototype.init = function init() {
    var self = this;
    var src = self.src;

    self.version = version;

    typeof self.onReady === "function" && self.onReady(self.ctx, self);

    if (src) {
      self.pushOrign(src);
    } else {
      self.updateCanvas();
    }
    setTouchState(self, false, false, false);

    self.oldScale = 1;
    self.newScale = 1;

    return self;
  };

  Object.assign(WeCropper.prototype, handle);

  WeCropper.prototype.prepare = prepare;
  WeCropper.prototype.observer = observer;
  WeCropper.prototype.methods = methods;
  WeCropper.prototype.cutt = cut;
  WeCropper.prototype.update = update;

  return WeCropper;
});

export default WeCropper;
